/**
 * 流转与任务结合的业务逻辑
 */

const TaskModel = require('../config/models_config').task_model;
const ResearchStateBiz = require('./research_state_biz.js');
const { FLOW_TASK_CONFIG, TASK_COMPLETION_CONFIG, ROLE_USER_MAP } = require('../config/flow_task_config.js');
const ResearchService = require('../service/research_service.js');
const dbUtil = require('../../../framework/database/db_util.js');
const timeUtil = require('../../../framework/helpers/time_util.js');
const UserModel = require('../config/models_config').user_model;

/**
 * 根据角色获取用户ID
 * @param {String} role 角色名称
 * @param {String} projectId 项目ID
 * @returns {Promise<String>} 用户ID
 */
async function getUserIdByRole(role, projectId) {
    // 先检查预设的角色映射
    if (ROLE_USER_MAP[role]) {
        return ROLE_USER_MAP[role];
    }
    
    // 如果没有预设，则根据项目和角色从数据库查询
    // 这里仅为示例，实际查询逻辑可能需要根据具体的数据结构调整
    try {
        const service = new ResearchService();
        const project = await service.getResearchDetail(projectId);
        
        if (!project) return '';
        
        // 根据角色名称获取对应的用户ID
        switch(role) {
            case 'PROJECT_MANAGER':
                return project.PROJECT_MANAGER_ID || '';
            case 'HARDWARE_ENGINEER':
                return project.HARDWARE_ENGINEER_ID || '';
            case 'SOFTWARE_ENGINEER':
                return project.SOFTWARE_ENGINEER_ID || '';
            // 更多角色映射...
            default:
                return '';
        }
    } catch (err) {
        console.error('根据角色获取用户ID失败', err);
        return '';
    }
}

/**
 * 为项目状态创建关联任务
 * @param {String} projectId 项目ID
 * @param {Number} status 项目状态
 * @param {Number} activeStatus 项目活动状态
 * @param {String} userId 操作用户ID
 * @returns {Promise} 异步结果
 */
async function createTasksForProjectStatus(projectId, status, activeStatus, userId) {
    try {
        if (!projectId) return { code: -1, message: '项目ID不能为空' };
        
        // 获取项目详情
        const service = new ResearchService();
        const project = await service.getResearchDetail(projectId);
        
        if (!project) {
            return { code: -1, message: '项目不存在' };
        }
        
        // 获取当前状态对应的任务配置
        const tasks = FLOW_TASK_CONFIG[status] || [];
        if (tasks.length === 0) {
            return { code: 0, message: '当前状态无需创建任务' };
        }
        
        // 处理每个任务
        const taskModel = new TaskModel();
        let createdCount = 0;
        
        for (let taskConfig of tasks) {
            // 获取任务负责人ID
            const assigneeId = await getUserIdByRole(taskConfig.assignRole, projectId);
            
            // 创建任务数据
            let taskData = {
                TASK_ID: await dbUtil.getNewId(),
                TASK_TITLE: taskConfig.title,
                TASK_PROJECT_ID: projectId,
                TASK_TYPE: taskConfig.type,
                TASK_STATUS: TaskModel.STATUS.NOT_STARTED,
                TASK_PRIORITY: taskConfig.priority,
                TASK_DESCRIPTION: taskConfig.description,
                
                TASK_PLAN_START_TIME: timeUtil.time(),
                TASK_PLAN_END_TIME: timeUtil.time() + (taskConfig.estimatedHours || 24) * 3600,
                TASK_ESTIMATED_HOURS: taskConfig.estimatedHours || 0,
                TASK_PROGRESS: 0,
                
                TASK_ASSIGNEE_ID: assigneeId,
                TASK_REPORTER_ID: userId,
                
                TASK_ADD_USER_ID: userId,
                TASK_ADD_TIME: timeUtil.time(),
                TASK_EDIT_TIME: timeUtil.time()
            };
            
            // 插入数据库
            let result = await taskModel.insert(taskData);
            if (result) createdCount++;
        }
        
        return {
            code: 0,
            message: `成功创建 ${createdCount} 个任务`
        };
    } catch (err) {
        console.error('创建任务失败', err);
        return { code: -1, message: '创建任务失败：' + err.message };
    }
}

/**
 * 检查任务完成情况，判断是否可以流转状态
 * @param {String} projectId 项目ID
 * @returns {Promise} 异步结果
 */
async function checkProjectTransitionCondition(projectId) {
    try {
        if (!projectId) return { code: -1, message: '项目ID不能为空' };
        
        // 获取项目详情
        const service = new ResearchService();
        const project = await service.getResearchDetail(projectId);
        
        if (!project) {
            return { code: -1, message: '项目不存在' };
        }
        
        const currentStatus = project.PROJECT_STATUS || 0;
        const currentActiveStatus = project.PROJECT_ACTIVE_STATUS || 0;
        
        // 构建查询键
        const configKey = `${currentStatus}_${currentStatus + 1}`;
        
        // 获取流转配置
        const transitionConfig = TASK_COMPLETION_CONFIG[configKey];
        if (!transitionConfig) {
            return { code: 0, message: '当前状态无任务完成条件检查' };
        }
        
        // 查询相关任务
        const taskModel = new TaskModel();
        let tasks = await dbUtil.getAll(TaskModel.CL, {
            TASK_PROJECT_ID: projectId,
            TASK_TITLE: dbUtil.in(transitionConfig.requiredTasks)
        });
        
        if (!tasks || tasks.length === 0) {
            return { code: 0, message: '未找到相关任务' };
        }
        
        // 检查任务完成情况
        let allCompleted = true;
        let completedCount = 0;
        
        for (let task of tasks) {
            if (task.TASK_STATUS === TaskModel.STATUS.COMPLETED) {
                completedCount++;
            } else {
                allCompleted = false;
            }
        }
        
        // 如果配置要求所有任务完成，但不是所有任务都完成
        if (transitionConfig.allRequired && !allCompleted) {
            return {
                code: 0,
                message: `任务完成 ${completedCount}/${transitionConfig.requiredTasks.length}，暂不满足流转条件`
            };
        }
        
        // 如果不要求所有完成，但完成数为0
        if (!transitionConfig.allRequired && completedCount === 0) {
            return {
                code: 0,
                message: '尚未完成任何任务，暂不满足流转条件'
            };
        }
        
        // 满足流转条件，自动流转状态
        const result = await ResearchStateBiz.transitProjectState(
            projectId,
            transitionConfig.nextStatus,
            transitionConfig.nextActiveStatus,
            { note: '基于任务完成自动流转状态' }
        );
        
        if (result.code === 0) {
            return {
                code: 0,
                message: '任务已完成，已自动流转项目状态',
                data: {
                    nextStatus: transitionConfig.nextStatus,
                    nextActiveStatus: transitionConfig.nextActiveStatus
                }
            };
        } else {
            return {
                code: 0,
                message: '任务已完成，但状态流转失败：' + result.message
            };
        }
    } catch (err) {
        console.error('检查任务完成状态失败', err);
        return { code: -1, message: '检查任务完成状态失败：' + err.message };
    }
}

/**
 * 更新任务状态
 * @param {String} taskId 任务ID
 * @param {Number} status 任务状态
 * @param {Number} progress 任务进度
 * @param {String} userId 操作用户ID
 * @returns {Promise} 异步结果
 */
async function updateTaskStatus(taskId, status, progress, userId) {
    try {
        if (!taskId) return { code: -1, message: '任务ID不能为空' };
        
        const taskModel = new TaskModel();
        const task = await taskModel.getOne({ _id: taskId });
        
        if (!task) {
            return { code: -1, message: '任务不存在' };
        }
        
        // 更新任务数据
        let updateData = {
            TASK_STATUS: status,
            TASK_EDIT_TIME: timeUtil.time()
        };
        
        // 如果提供了进度，则更新进度
        if (progress !== undefined && progress !== null) {
            updateData.TASK_PROGRESS = progress;
        }
        
        // 如果是设置为已完成状态，则记录实际结束时间
        if (status === TaskModel.STATUS.COMPLETED) {
            updateData.TASK_ACTUAL_END_TIME = timeUtil.time();
            updateData.TASK_PROGRESS = 100;
            
            // 如果之前是未开始状态，则同时设置实际开始时间
            if (task.TASK_STATUS === TaskModel.STATUS.NOT_STARTED) {
                updateData.TASK_ACTUAL_START_TIME = timeUtil.time();
            }
        }
        
        // 如果是从未开始改为进行中，则记录实际开始时间
        if (task.TASK_STATUS === TaskModel.STATUS.NOT_STARTED && 
            status === TaskModel.STATUS.IN_PROGRESS) {
            updateData.TASK_ACTUAL_START_TIME = timeUtil.time();
        }
        
        // 更新数据库
        const result = await taskModel.edit({ _id: taskId }, updateData);
        
        if (!result) {
            return { code: -1, message: '更新任务状态失败' };
        }
        
        // 如果任务完成，检查是否可以流转项目状态
        if (status === TaskModel.STATUS.COMPLETED) {
            await checkProjectTransitionCondition(task.TASK_PROJECT_ID);
        }
        
        return { 
            code: 0, 
            message: '更新任务状态成功',
            task: {
                ...task,
                ...updateData
            }
        };
    } catch (err) {
        console.error('更新任务状态失败', err);
        return { code: -1, message: '更新任务状态失败：' + err.message };
    }
}

module.exports = {
    createTasksForProjectStatus,
    checkProjectTransitionCondition,
    updateTaskStatus
}; 